// use std::sync::{
//     atomic::{AtomicU64, Ordering},
//     Arc, Mutex,
// };

// use axum::{
//     http::Request,
//     middleware::{self, Next},
//     response::IntoResponse,
//     Extension, Router,
// };
// use tower::ServiceBuilder;
// use tracing::{debug, Level};

// #[derive(Debug)]
// struct AppState {
//     counter: AtomicU64,
//     data: Mutex<String>,
// }

// impl AppState {
//     fn add_one(&self) {
//         self.counter.fetch_add(1, Ordering::SeqCst);
//     }

//     fn set_data(&self, _data: &str) {
//         *self.data.lock().unwrap() = _data.to_string();
//     }
// }

// #[tokio::test]
// async fn run() {
//     tracing_subscriber::fmt()
//         .with_max_level(Level::DEBUG)
//         .init();

//     let add_str = "0.0.0.0:3000";

//     let shared_state = Arc::new(AppState {
//         counter: 0u64.into(),
//         data: Mutex::new("".to_string()),
//     });

//     // 中间件组合栈
//     let middlewares_stack = ServiceBuilder::new()
//         .layer(Extension(shared_state))
//         .layer(middleware::from_fn(mid_handler_a))
//         .layer(middleware::from_fn(mid_handler_b));

//     let app = Router::new()
//         .route("/", axum::routing::get(root_fn))
//         .route("/hello", axum::routing::get(hello_fn))
//         .layer(middlewares_stack)
//         // middlewares_stack 中的处理不会影响其后面的router
//         .route("/after", axum::routing::get(after_fn));

//     let addr = add_str.parse().unwrap();
//     debug!("listening on {}", addr);
//     axum::Server::bind(&addr)
//         .serve(app.into_make_service())
//         .await
//         .unwrap();
// }

// async fn root_fn(Extension(state): Extension<Arc<AppState>>) -> String {
//     format!("ROOT! counter:{:?}", state)
// }

// async fn hello_fn(Extension(state): Extension<Arc<AppState>>) -> String {
//     format!("hello world! state:{:?}", state)
// }

// async fn after_fn() -> String {
//     format!("after!")
// }

// async fn mid_handler_a(
//     Extension(state): Extension<Arc<AppState>>,
//     req: Request,
//     next: Next,
// ) -> impl IntoResponse
// {
//     state.add_one();
//     debug!("handle mid_handler_a request: {:?}", req);
//     let resp = next.run(req).await;
//     debug!("handle mid_handler_a response: {:?}", resp);
//     resp
// }

// async fn mid_handler_b(
//     Extension(state): Extension<Arc<AppState>>,
//     req: Request,
//     next: Next,
// ) -> impl IntoResponse
// {
//     debug!("handle mid_handler_b request: {:?}", req);
//     state.set_data("set msg in mid_handler_b");
//     let resp = next.run(req).await;
//     debug!("handle mid_handler_b response: {:?}", resp);
//     resp
// }
